home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume26 / macps-2.3 / part01 next >
Encoding:
Text File  |  1993-06-19  |  47.7 KB  |  1,662 lines

  1. Newsgroups: comp.sources.unix
  2. From: edmoy@violet.Berkeley.EDU (Edward Moy)
  3. Subject: v26i243: macps-2.3 - Print Mac files on UNIX, Part01/01
  4. Sender: unix-sources-moderator@gw.home.vix.com
  5. Approved: vixie@gw.home.vix.com
  6.  
  7. Submitted-By: edmoy@violet.Berkeley.EDU (Edward Moy)
  8. Posting-Number: Volume 26, Issue 243
  9. Archive-Name: macps-2.3/part01
  10.  
  11. Well, here is the long-overdue System 7 compatible version of macps and
  12. prepfix, version 2.3, in shar format.  Following are some excerpts from
  13. the included ReadMe file.
  14.  
  15. Edward Moy                Principal Programmer - Macintosh & Unix
  16. Workstation Support Services        Workstation Software Support Group
  17. University of California
  18. Berkeley, CA  94720
  19.  
  20. #! /bin/sh
  21. # This is a shell archive.  Remove anything before this line, then unpack
  22. # it by saving it into a file and typing "sh file".  To overwrite existing
  23. # files, type "sh file -c".  You can also feed this as standard input via
  24. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  25. # will see the following message at the end:
  26. #        "End of archive 1 (of 1)."
  27. # Contents:  Installation MANIFEST Makefile ReadMe macaux.c macps.1
  28. #   macps.c macps.config prepfix.1 prepfix.c str.h ucbwhich.c
  29. #   ucbwhich.h
  30. # Wrapped by vixie@gw.home.vix.com on Sun Jun 20 12:17:16 1993
  31. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  32. if test -f 'Installation' -a "${1}" != "-c" ; then 
  33.   echo shar: Will not clobber existing file \"'Installation'\"
  34. else
  35. echo shar: Extracting \"'Installation'\" \(4025 characters\)
  36. sed "s/^X//" >'Installation' <<'END_OF_FILE'
  37. XInstallation Instructions (SCCSid = "@(#)Installation    2.3 7/1/92")
  38. X
  39. X1) Look at the Makefile.  There are three CFLAGS options that you can
  40. Xuse.  Setting SYSV should allow macps and prepfix to compile on System
  41. XV machines (I've only tried it under A/UX).  Setting CONFIGDIR will
  42. Xcause macps to look for macps.config in that directory.  Setting SAVE
  43. Xwill cause macps to enclose the entire print job is a PostScript
  44. Xsave/restore context.  Normally you don't need SAVE, since most
  45. Xspooling software will automatically do an EOF between print jobs,
  46. Xwhich effectively does a restore of memory for you, but some spooling
  47. Xsoftware does require the save/restore.  Note that defining SAVE will
  48. Xcause printing to fail on a NeXT laser printer, while it is harmless on
  49. Xmost other systems.
  50. X
  51. XThe options will look something like:
  52. X
  53. XCFLAGS = -O -DSYSV -DCONFIGDIR=\"/usr/new/lib\" -DSAVE
  54. X
  55. Xif you defined all the options.
  56. X
  57. X2) Type "make".  If all goes well, macps and prepfix will be created.
  58. X
  59. X3) For pre-System 7 systems, to create the unprocessed LaserPrep file
  60. Xon the Mac, as well as creating the raw PostScript files that you want
  61. Xto print, make sure that either you're not running MultiFinder, or if
  62. Xyou are, go to the Chooser under the Apple menu, click on the
  63. XLaserWriter icon and then turn off Background Printing.  (No special
  64. Xsetting need to be made under System 7.)
  65. X
  66. X4a) Under a pre-System 7 system, for each version of LaserPrep on the
  67. XMac that you want to include, install that version in the System
  68. XFolder.  Then, open an empty document in some simple application (one
  69. Xthat doesn't have its own ProcSet to download).  Choose Print from the
  70. XFile menu and the LaserWriter print dialog will appear.  Click on the
  71. XOK button and IMMEDIATELY press and hold Command-K.  When a dialog box
  72. Xappears telling you that it is creating a PostScript file, you can
  73. Xrelease Command-K.  The unprocessed LaserPrep file will usually be
  74. Xfound in one of three places, in the System Folder, in the same folder
  75. Xas the application or at the top level of the disk.
  76. X
  77. X4b) Under a System 7 system, make sure that the LaserWriter driver is
  78. Xinstalled in the System Folder.  Then, open an empty document in some
  79. Xsimple application (one that doesn't have its own ProcSet to
  80. Xdownload).  Choose Print from the File menu and the LaserWriter print
  81. Xdialog will appear.  Click on the PostScript File radio button, and
  82. Xthen click on the Save button.  When the standard file dialog box
  83. Xappears, specify a name and folder for the PostScript file, and click
  84. Xon the Save button.
  85. X
  86. X5) Upload the PostScript file(s) to Unix, using some file transfer
  87. Xprogram like MacTerminal, Versaterm, Red Ryder, MacKermit or ftp.
  88. X
  89. X6) Run prepfix on each unprocessed file, diverting the standard output
  90. Xto an appropriataly named file (like LaserPrep5.2).  If you want to
  91. Xallow bit smoothing on a non-Apple PostScript printer, specify the -l
  92. Xoption to prepfix (you can specify as many printer names as you want,
  93. Xeach with a separate -l flag).  If you aren't sure the your printer can
  94. Xdo smoothing, you can try it and see if it works (if it doesn't, you
  95. Xcan always re-run prepfix on the unprocessed file(s), leaving off the
  96. Xprinter that doesn't work).  If you don't know the product name for you
  97. Xprinter, you can use the following PostScript code to print it:
  98. X
  99. X%!
  100. X/in {72 mul} def
  101. X/Courier findfont 18 scalefont setfont
  102. X1 in 8 in moveto
  103. Xstatusdict /product get show
  104. Xshowpage
  105. X
  106. X7) Put the modified LaserPrep file(s) in some directory and modify the
  107. Xmacps.config file to point to these LaserPrep files.  Then put the
  108. Xmacps.config file in a "lib" subdirectory to where you install macps
  109. X(or in the directory CONFIGDIR if you used that option).
  110. X
  111. X8) Now when you want to print something, do the same thing as in step 4
  112. Xabove with the LaserWriter print dialog, except for pre-System 7
  113. Xsystem, press and hold Command-F (this cause LaserPrep not to be
  114. Xincluded in the PostScript file).
  115. X
  116. X9) Upload the PostScript file and run macps on it, sending the output
  117. Xto your printer, as in:
  118. X
  119. X    % macps psfile | lpr
  120. END_OF_FILE
  121. if test 4025 -ne `wc -c <'Installation'`; then
  122.     echo shar: \"'Installation'\" unpacked with wrong size!
  123. fi
  124. # end of 'Installation'
  125. fi
  126. if test -f 'MANIFEST' -a "${1}" != "-c" ; then 
  127.   echo shar: Will not clobber existing file \"'MANIFEST'\"
  128. else
  129. echo shar: Extracting \"'MANIFEST'\" \(517 characters\)
  130. sed "s/^X//" >'MANIFEST' <<'END_OF_FILE'
  131. X   File Name        Archive #    Description
  132. X-----------------------------------------------------------
  133. X Installation               1    
  134. X MANIFEST                   1    This shipping list
  135. X Makefile                   1    
  136. X ReadMe                     1    
  137. X macaux.c                   1    
  138. X macps.1                    1    
  139. X macps.c                    1    
  140. X macps.config               1    
  141. X prepfix.1                  1    
  142. X prepfix.c                  1    
  143. X str.h                      1    
  144. X ucbwhich.c                 1    
  145. X ucbwhich.h                 1    
  146. END_OF_FILE
  147. if test 517 -ne `wc -c <'MANIFEST'`; then
  148.     echo shar: \"'MANIFEST'\" unpacked with wrong size!
  149. fi
  150. # end of 'MANIFEST'
  151. fi
  152. if test -f 'Makefile' -a "${1}" != "-c" ; then 
  153.   echo shar: Will not clobber existing file \"'Makefile'\"
  154. else
  155. echo shar: Extracting \"'Makefile'\" \(1251 characters\)
  156. sed "s/^X//" >'Makefile' <<'END_OF_FILE'
  157. X# Copyright (c) 1988, 1992, The Regents of the University of California.
  158. X# Edward Moy, Workstation Software Support Group, Workstation Support Serices,
  159. X# Information Systems and Technology.
  160. X#
  161. X# Permission is granted to any individual or institution to use, copy,
  162. X# or redistribute this software so long as it is not sold for profit,
  163. X# provided that this notice and the original copyright notices are
  164. X# retained.  The University of California makes no representations about the
  165. X# suitability of this software for any purpose.  It is provided "as is"
  166. X# without express or implied warranty.
  167. X#
  168. X# SCCSid = "@(#)Makefile    2.3 7/1/92"
  169. X#
  170. X# For System V, include -DSYSV in CFLAGS below.
  171. X# To specify a fixed path for macps.config, include -DCONFIGDIR=\"path\"
  172. X# in CFLAGS below (path is the full pathname of the directory).
  173. X# To do save/restore context, include -DSAVE in CFLAGS below.
  174. X#
  175. XCFLAGS = -O
  176. XMACPS = macps.o macaux.o ucbwhich.o
  177. XPREPFIX = prepfix.o macaux.o
  178. X
  179. Xall : macps prepfix
  180. X
  181. Xmacps : $(MACPS)
  182. X    cc -o macps $(CFLAGS) $(MACPS)
  183. X
  184. Xprepfix : $(PREPFIX)
  185. X    cc -o prepfix $(CFLAGS) $(PREPFIX)
  186. X
  187. Xmacps.o : macps.c str.h ucbwhich.h
  188. X
  189. Xmacaux.o : macaux.c str.h
  190. X
  191. Xprepfix.o : prepfix.c str.h
  192. X
  193. Xucbwhich.o : ucbwhich.c ucbwhich.h
  194. X
  195. Xclean :
  196. X    /bin/rm -f *.o macps prepfix
  197. END_OF_FILE
  198. if test 1251 -ne `wc -c <'Makefile'`; then
  199.     echo shar: \"'Makefile'\" unpacked with wrong size!
  200. fi
  201. # end of 'Makefile'
  202. fi
  203. if test -f 'ReadMe' -a "${1}" != "-c" ; then 
  204.   echo shar: Will not clobber existing file \"'ReadMe'\"
  205. else
  206. echo shar: Extracting \"'ReadMe'\" \(5897 characters\)
  207. sed "s/^X//" >'ReadMe' <<'END_OF_FILE'
  208. XCOPYRIGHT NOTICE (SCCSid = "@(#)ReadMe    2.3 7/3/92")
  209. X
  210. XCopyright (C) 1988, 1992, The Regents of the University of California.
  211. XEdward Moy, Workstation Software Support Group, Workstation Support
  212. XSerices, Information Systems and Technology.
  213. X
  214. XPermission is granted to any individual or institution to use, copy, or
  215. Xredistribute this software so long as it is not sold for profit,
  216. Xprovided that this notice and the original copyright notices are
  217. Xretained.  The University of California makes no representations about
  218. Xthe suitability of this software for any purpose.  It is provided "as
  219. Xis" without express or implied warranty.
  220. X
  221. XWHAT IS MACPS?
  222. X
  223. XMacps is a Unix program that takes an uploaded PostScript file created
  224. Xon a Macintosh (see macps.1 for more details) and includes an
  225. Xappropriately modified LaserPrep file so that the result can be sent to
  226. Xa PostScript printer from Unix.  The LaserPrep file contains macros
  227. Xused by the PostScript generator on the Macintosh.
  228. X
  229. XWHY IS MACPS NEEDED?
  230. X
  231. XThis is how Mac printing works.  When a Mac talks to a LaserWriter, it
  232. Xasks if the LaserWriter has had a LaserPrep file downloaded to it.  A
  233. XLaserWriter that is first powered up, has no such LaserPrep file, and
  234. Xso the Mac downloads it and makes the LaserPrep file resident in
  235. Xmemory.  Then the actual print file is sent to the LaserWriter.
  236. XSubsequent print requests need not download the LaserPrep file, unless
  237. Xit is a different version.
  238. X
  239. XSince a LaserWriter connected to a Unix system usually does things
  240. Xother than Mac printing, it is unwise to make LaserPrep files resident
  241. Xin memory so that other PostScript jobs have less memory to work with.
  242. XWhat prepfix does is to modify a LaserPrep file so that, among other
  243. Xthings, it does not make itself resident in memory.  Thus, the
  244. XLaserPrep file must be downloaded for each Mac print job.  This is the
  245. Xfunction of macps, to automatically append the appropriate LaserPrep
  246. Xfile.
  247. X
  248. XSince System 7, the LaserPrep is no longer downloaded to the printer.
  249. XSome people have had success printing a System 7-generated PostScript
  250. Xfile directly, but using macps should make printing more reliable and
  251. Xavailable to non-Apple PostScript printers.
  252. X
  253. XWHICH VERSION OF THE LASERPREP WILL BE USED?
  254. X
  255. XMacps interprets the %%IncludeProcSet directive found in the PostScript
  256. Xgenerated by LaserWriter driver 4.0 and greater.  It takes the ProcSet
  257. Xid and looks it up in a file "macps.config", to get the pathname of the
  258. Xprep file, and thus macps can convert PostScript generated by different
  259. Xversions of the LaserWriter driver.
  260. X
  261. XHOW ARE THE LASERPREP FILES GENERATED?
  262. X
  263. XSince the Apple LaserPrep files are copyrighted, I've included a
  264. Xprogram, prepfix, that reads version 4.0 and up LaserPrep files, and
  265. Xedits them so that they are (mostly) compatible with Unix (See
  266. Xprepfix.1 for more details).
  267. X
  268. XWHERE IS THE MACPS.CONFIG FILE LOCATED?
  269. X
  270. XMacps has some special code that is able to figure out from which
  271. Xdirectory it was called from.  It will then look in a "lib" subdiretory
  272. Xfor the macps.config file.
  273. X
  274. XWHAT ABOUT BIT-SMOOTHING ON NON-LASERWRITER PRINTERS?
  275. X
  276. XFor PostScript printers using Motorola 680x0 processors and Adobe
  277. XPostScript firmware other than LaserWriters, there is an option that
  278. Xwill allow these printers to do bit-smoothing, just like LaserWriters.
  279. X
  280. XCHANGES IN VERSION 2.3
  281. X
  282. XVersion 2.3 of prepfix now support LaserPrep 7.x (System 7).  Resulting
  283. XLaserPrep files are slightly smaller, since some extraneous comments
  284. Xhave been removed.  Version 2.3 of macps works with System 7-generated
  285. XPostScript files, replacing the included LaserPrep with the modified
  286. Xversion.  Because of the way this change was made, macps can now work
  287. Xon either a Command-F or Command-K (pre-System 7) PostScript file.
  288. X
  289. XCreating a PostScript file under System 7 will cause all fonts used in
  290. Xa document to be downloaded.  Downloaded fonts, especially TrueType
  291. Xfonts, tend to make the resulting PostScript file very large.  Both the
  292. Xsize of the PostScript file and the complexity of a downloadable
  293. XTrueType font can cause some printers to fail to print, even when the
  294. Xprinter already contains the requested fonts.  Software like H.M.
  295. XAyala's Trimmer CDEV (available from most Macintosh ftp sites and
  296. Xbulletin board systems) can prevents selected fonts (those already
  297. Xresident in the printer) from being downloaded.
  298. X
  299. XCHANGES IN VERSION 2.2
  300. X
  301. XVersion 2.2 of prepfix now supports LaserPrep 6.0.  The PostScript
  302. Xsave/restore context is now a compile-time option, since it caused
  303. Xprinting to fail on a NeXT printer (though it was harmless on most
  304. Xother printers).  This save/restore is now more intelligent about
  305. Xclearing the stacks.
  306. X
  307. XCHANGES IN VERSION 2.1
  308. X
  309. XVersion 2.1 of prepfix uses a safer method for turning on bit-smoothing
  310. Xfor non-Apple printers.  This should get around some of the problems
  311. Xpeople have been having with specialized macros in the LaserPreps that
  312. Xare Apple printer specific.  The -l and -p options in version 1.1 have
  313. Xbeen replaced with the single -l option, and the limit on the number
  314. Xof printers you can specify has been removed.
  315. X
  316. XAlso, prepfix removes some other various macros that cause
  317. Xunpredictable problems, and a problem with Apple LaserWriter II/NTs
  318. X(but not other Apple printers).
  319. X
  320. XVersion 2.1 macps has several new options.  The -c option allow you to
  321. Xspecify the number of copies to generate (overriding any multiple copy
  322. Xoption that was specified on the Macintosh).  The -d option allows an
  323. Xalternate directory to look for the macps.config file.  Finally, the -r
  324. X(raw) option suppresses the conversion of 8-bit binary into ASCII, and
  325. Xis useful for some graphics programs that manipulate gray-scale images,
  326. Xand produce 8-bit binary PostScript output.
  327. X
  328. XMacps will even work with a NeXT laser printer, but (at least the 0.8
  329. Xversion of the operating system) will not do bit smoothing.  Beware,
  330. Xthough, that if you print Macintosh patterns at 400 dpi, they will
  331. Xlook funny.
  332. END_OF_FILE
  333. if test 5897 -ne `wc -c <'ReadMe'`; then
  334.     echo shar: \"'ReadMe'\" unpacked with wrong size!
  335. fi
  336. # end of 'ReadMe'
  337. fi
  338. if test -f 'macaux.c' -a "${1}" != "-c" ; then 
  339.   echo shar: Will not clobber existing file \"'macaux.c'\"
  340. else
  341. echo shar: Extracting \"'macaux.c'\" \(3608 characters\)
  342. sed "s/^X//" >'macaux.c' <<'END_OF_FILE'
  343. X/*
  344. X * Copyright (c) 1988, 1992, The Regents of the University of California.
  345. X * Edward Moy, Workstation Software Support Group, Workstation Support Serices,
  346. X * Information Systems and Technology.
  347. X *
  348. X * Permission is granted to any individual or institution to use, copy,
  349. X * or redistribute this software so long as it is not sold for profit,
  350. X * provided that this notice and the original copyright notices are
  351. X * retained.  The University of California makes no representations about the
  352. X * suitability of this software for any purpose.  It is provided "as is"
  353. X * without express or implied warranty.
  354. X */
  355. X
  356. X#ifndef lint
  357. Xstatic char *SCCSid = "@(#)macaux.c    2.3 7/1/92";
  358. X#endif lint
  359. X
  360. X#include <ctype.h>
  361. X#include <stdio.h>
  362. X#include "str.h"
  363. X
  364. X#define    FALSE        0
  365. X#define    TRUE        1
  366. X
  367. Xextern char *myname;
  368. Xint rawmode = FALSE;
  369. X
  370. XSTR *
  371. XSTRalloc()
  372. X{
  373. X    register STR *str;
  374. X    char *malloc();
  375. X
  376. X    if((str = (STR *)malloc(sizeof(STR))) == NULL ||
  377. X     (str->bufptr = (byte *)malloc(STRSIZE)) == NULL) {
  378. X        fprintf(stderr, "%s: STRalloc: Out of memory\n", myname);
  379. X        exit(1);
  380. X    }
  381. X    str->curendptr = str->bufptr;
  382. X    str->realendptr = str->bufptr + STRSIZE;
  383. X    return(str);
  384. X}
  385. X
  386. XSTRfree(str)
  387. XSTR *str;
  388. X{
  389. X    free((char *)str->bufptr);
  390. X    free((char *)str);
  391. X}
  392. X
  393. XSTRexpand(str)
  394. Xregister STR *str;
  395. X{
  396. X    register int curend, realend;
  397. X    char *realloc();
  398. X
  399. X    curend = str->curendptr - str->bufptr;
  400. X    realend = (str->realendptr - str->bufptr) + STRSIZEDELTA;
  401. X    if((str->bufptr = (byte *)realloc((char *)str->bufptr,
  402. X     realend)) == NULL) {
  403. X        fprintf(stderr, "%s: STRexpand: Out of memory\n", myname);
  404. X        exit(1);
  405. X    }
  406. X    str->curendptr = str->bufptr + curend;
  407. X    str->realendptr = str->bufptr + realend;
  408. X}
  409. X
  410. XSTRgets(str, fp)
  411. Xregister STR *str;
  412. Xregister FILE *fp;
  413. X{
  414. X    register int c;
  415. X
  416. X    str->curendptr = str->bufptr;
  417. X    for( ; ; ) {
  418. X        if((c = getc(fp)) == EOF)
  419. X            return(str->curendptr > str->bufptr);
  420. X        if(str->curendptr >= str->realendptr)
  421. X            STRexpand(str);
  422. X        *str->curendptr++ = c;
  423. X        if(c == '\n' || c == '\r') {
  424. X            if(str->curendptr >= str->realendptr)
  425. X                STRexpand(str);
  426. X            *str->curendptr = 0;
  427. X            return(TRUE);
  428. X        }
  429. X    }
  430. X}
  431. X
  432. XSTRputsptr(str, cp, fp)
  433. Xregister STR *str;
  434. Xregister byte *cp;
  435. Xregister FILE *fp;
  436. X{
  437. X    if(rawmode) {
  438. X        for( ; cp < str->curendptr ; cp++)
  439. X            putc(*cp, fp);
  440. X        return;
  441. X    }
  442. X    for( ; cp < str->curendptr ; cp++) {
  443. X        if(!isascii(*cp))
  444. X            fprintf(fp, "\\%03o", *cp);
  445. X        else if(isprint(*cp))
  446. X            putc(*cp, fp);
  447. X        else {
  448. X            switch(*cp) {
  449. X             case '\n':
  450. X             case '\r':
  451. X                putc('\n', fp);
  452. X                continue;
  453. X             case '\t':
  454. X                putc('\t', fp);
  455. X                continue;
  456. X             default:
  457. X                fprintf(fp, "\\%03o", *str);
  458. X                continue;
  459. X            }
  460. X        }
  461. X    }
  462. X}
  463. X
  464. XSTRcompareptr(str, cp, sp)
  465. Xregister STR *str;
  466. Xregister byte *cp, *sp;
  467. X{
  468. X    register int comp;
  469. X
  470. X    for( ; ; ) {
  471. X        if(*sp == 0)
  472. X            return(cp >= str->curendptr ? 0 : 1);
  473. X        if(cp >= str->curendptr)
  474. X            return(-1);
  475. X        if(*sp == '\n') {
  476. X            if(*cp != '\n' && *cp != '\r')
  477. X                return((int)*cp - (int)*sp);
  478. X        } else if((comp = (int)*cp - (int)*sp) != 0)
  479. X            return(comp);
  480. X        cp++;
  481. X        sp++;
  482. X    }
  483. X}
  484. X
  485. XSTRheadcmpptr(str, cp, sp)
  486. Xregister STR *str;
  487. Xregister byte *cp, *sp;
  488. X{
  489. X    register int comp;
  490. X
  491. X    for( ; ; ) {
  492. X        if(*sp == 0)
  493. X            return(0);
  494. X        if(cp >= str->curendptr)
  495. X            return(-1);
  496. X        if(*sp == '\n') {
  497. X            if(*cp != '\n' && *cp != '\r')
  498. X                return((int)*cp - (int)*sp);
  499. X        } else if((comp = (int)*cp - (int)*sp) != 0)
  500. X            return(comp);
  501. X        cp++;
  502. X        sp++;
  503. X    }
  504. X}
  505. X
  506. Xbyte *
  507. XSTRmatch(str, sp)
  508. Xregister STR *str;
  509. Xregister byte *sp;
  510. X{
  511. X    register byte *mp, *last;
  512. X    register int firstchar;
  513. X
  514. X    firstchar = *sp;
  515. X    last = str->curendptr - strlen(sp);
  516. X    mp = str->bufptr;
  517. X    while(mp <= last) {
  518. X        if(*mp == firstchar && STRheadcmpptr(str, mp, sp) == 0)
  519. X            return(mp);
  520. X        mp++;
  521. X    }
  522. X    return(NULL);
  523. X}
  524. END_OF_FILE
  525. if test 3608 -ne `wc -c <'macaux.c'`; then
  526.     echo shar: \"'macaux.c'\" unpacked with wrong size!
  527. fi
  528. # end of 'macaux.c'
  529. fi
  530. if test -f 'macps.1' -a "${1}" != "-c" ; then 
  531.   echo shar: Will not clobber existing file \"'macps.1'\"
  532. else
  533. echo shar: Extracting \"'macps.1'\" \(4288 characters\)
  534. sed "s/^X//" >'macps.1' <<'END_OF_FILE'
  535. X.\" SCCSid = "@(#)macps.1    2.3 7/3/92"
  536. X.TH MACPS 1 "1 July 1992"
  537. X.UC 4
  538. X.SH NAME
  539. Xmacps \- print Macintosh-created PostScript file on Unix
  540. X.SH SYNOPSIS
  541. X.B macps
  542. X[
  543. X\-c copies
  544. X]
  545. X[
  546. X\-d directory
  547. X]
  548. X[
  549. X\-r
  550. X]
  551. X[
  552. Xfile
  553. X]
  554. X.SH DESCRIPTION
  555. X.I Macps
  556. Xtakes the command-line file (or the standard input if no filename is given),
  557. Xand prepends the appropriate Macintosh LaserPrep file (e.g., those generated
  558. Xby
  559. X.IR prepfix (1)).
  560. XThe standard output can then be directed to a PostScript printer, via
  561. X.IR lpr (1),
  562. Xfor example.
  563. X.PP
  564. XThe input PostScript file is generated on a Macintosh in one of two ways.
  565. XOn pre-System 7 systems, this PostScript file is created by typing (and
  566. Xholding) Command-F immediately after clicking the OK button of the LaserWriter
  567. XPrint dialog box.
  568. XAnother dialog will appear, confirming that a file named ``PostScript'' is
  569. Xbeing created (the Command-F keys can be released now).
  570. XDepending on the application, the created PostScript file can be found in the
  571. XSystem Folder, the application folder or the top level of the disk.
  572. X.PP
  573. XOn System 7 systems, the Print dialog box allows the selection of the
  574. Xdestination of the output.
  575. XClicking on the PostScript File radio button and then clicking the Save button
  576. Xwill cause a standard file dialog box to appear, allowing the user to specify
  577. Xthe name and location of the resultant PostScript file.
  578. X.PP
  579. XThe PostScript file can then be uploaded via some file transfer program, such
  580. Xas MacTerminal/VersaTerm and
  581. X.IR macget (1),
  582. XMacKermit/Red Ryder and
  583. X.IR kermit (1)
  584. Xor
  585. X.IR ftp (1).
  586. X.PP
  587. XNormally, you would specify the number of copies in the LaserWriter
  588. XPrint dialog box on the Macintosh.
  589. XHowever, you can override that after uploading the PostScript file by
  590. Xspecifying the
  591. X.B \-c
  592. Xoption, followed by the number of copies.
  593. X.PP
  594. XIn a Macintosh PostScript file, the line beginning with ``%%IncludeProcSet:''
  595. Xis a request to include a LaserPrep with the internal name that follows on
  596. Xthe same line as the ``%%IncludeProcSet:'' directive.
  597. XThis internal name corresponds to the name in a LaserPrep file that follows
  598. Xon the same line as the ``%%BeginProcSet:'' directive.
  599. X.PP
  600. XTo specify where a LaserPrep file with a certain internal name is stored, a
  601. Xfile named
  602. X.B macps.config
  603. Xis used.
  604. XThis file is composed of one of more lines; one for each LaserPrep file.
  605. XEach line contains the internal name followed a tab character followed by
  606. Xthe name of file containing the corresponding LaserPrep.
  607. XThe file name can be either a full pathname or a pathname relative
  608. Xto the directory that
  609. X.B macps.config
  610. Xresides.
  611. X.PP
  612. XThe
  613. X.B macps.config
  614. Xfile is normally located in a `lib' subdirectory of the directory
  615. X.I macps
  616. Xis located.
  617. XThe
  618. X.B \-d
  619. Xoption allow you to specify an alternate directory in which the
  620. X.B macps.config
  621. Xfile can be found.
  622. X.PP
  623. XMost Macintosh applications produce normal ASCII PostScript files.
  624. XHowever, some graphics programs that manipulate gray-scale images will
  625. Xproduce PostScript files that contain 8-bit binary data.
  626. XSince
  627. X.I macps
  628. Xnormally converts this binary data, these PostScript files will not work
  629. Xproperly.
  630. XThe
  631. X.B \-r
  632. X(raw) option suppresses this binary conversion.
  633. X(Note: Depending on how the printer is physically connected, it may not be
  634. Xable to handle 8-bit binary data properly, and results may be disappointing.)
  635. X.SH FILES
  636. X.TP "\w'lib/macps.config     'u"
  637. Xlib/macps.config
  638. XMaps ProcSet internal names to LaserPrep filenames
  639. X.SH "SEE ALSO"
  640. Xlpr(1), macget(1), kermit(1), prepfix(1)
  641. X.SH BUGS
  642. X.I Macps
  643. Xonly works with version 4.0 and up of the Macintosh LaserPrep files.
  644. X.PP
  645. XBecause of the way bit smoothing is implemented by the LaserWriter driver,
  646. Xsome PostScript printers other than the Apple LaserWriters may not be able to
  647. Xbit smooth.
  648. X.PP
  649. XCreating a PostScript file under System 7 will cause all fonts used in
  650. Xa document to be downloaded.
  651. XDownloaded fonts, especially TrueType fonts, tend to make the resulting
  652. XPostScript file very large.
  653. XBoth the size of the PostScript file and the complexity of a downloadable
  654. XTrueType font can cause some printers to fail to print, even when the
  655. Xprinter already contains the requested fonts.
  656. XSoftware like H.M. Ayala's Trimmer CDEV (available from most Macintosh ftp
  657. Xsites and bulletin board systems) can prevents selected fonts (those already
  658. Xresident in the printer) from being downloaded.
  659. END_OF_FILE
  660. if test 4288 -ne `wc -c <'macps.1'`; then
  661.     echo shar: \"'macps.1'\" unpacked with wrong size!
  662. fi
  663. # end of 'macps.1'
  664. fi
  665. if test -f 'macps.c' -a "${1}" != "-c" ; then 
  666.   echo shar: Will not clobber existing file \"'macps.c'\"
  667. else
  668. echo shar: Extracting \"'macps.c'\" \(7130 characters\)
  669. sed "s/^X//" >'macps.c' <<'END_OF_FILE'
  670. X/*
  671. X * Copyright (c) 1988, 1992, The Regents of the University of California.
  672. X * Edward Moy, Workstation Software Support Group, Workstation Support Serices,
  673. X * Information Systems and Technology.
  674. X *
  675. X * Permission is granted to any individual or institution to use, copy,
  676. X * or redistribute this software so long as it is not sold for profit,
  677. X * provided that this notice and the original copyright notices are
  678. X * retained.  The University of California makes no representations about the
  679. X * suitability of this software for any purpose.  It is provided "as is"
  680. X * without express or implied warranty.
  681. X */
  682. X
  683. X#ifndef lint
  684. Xstatic char *SCCSid = "@(#)macps.c    2.3 7/1/92";
  685. X#endif lint
  686. X
  687. X#include <ctype.h>
  688. X#include <stdio.h>
  689. X#ifdef SYSV
  690. X#include <string.h>
  691. X#else SYSV
  692. X#include <strings.h>
  693. X#endif SYSV
  694. X#include <sys/types.h>
  695. X#include <sys/file.h>
  696. X#include "str.h"
  697. X#include "ucbwhich.h"
  698. X
  699. X#define    BEGINPROC    1
  700. X#define    CONFIG        "macps.config"
  701. X#define    INCLUDEPROC    0
  702. X#define    PS_INCLUDED    0x1
  703. X
  704. X#ifdef SYSV
  705. X#define    index        strchr
  706. X#define    rindex        strrchr
  707. X#endif SYSV
  708. X
  709. Xtypedef struct procset_str {
  710. X    struct procset_str *next;
  711. X    char *procset;
  712. X    char *path;
  713. X    short flags;
  714. X} ProcSet;
  715. X
  716. XProcSet *firstprocset;
  717. X#ifdef SAVE
  718. Xchar *finale = "clear countdictstack 2 sub{end}repeat macps restore\n";
  719. Xchar intro[] = "\
  720. X%%! *** Created by macps: %s\
  721. X/macps save def\n\
  722. X";
  723. X#else SAVE
  724. Xchar intro[] = "\
  725. X%%! *** Created by macps: %s\
  726. X";
  727. X#endif SAVE
  728. XProcSet *lastprocset;
  729. Xchar *myname;
  730. Xint ncopies = 0;
  731. X#ifdef CONFIGDIR
  732. Xchar ucblib[UCBMAXPATHLEN] = CONFIGDIR;
  733. X#else CONFIGDIR
  734. Xint ucbalternate;
  735. Xchar ucbpath[UCBMAXPATHLEN];
  736. Xchar ucblib[UCBMAXPATHLEN];
  737. X#endif CONFIGDIR
  738. X
  739. Xvoid copyproc();
  740. XProcSet *findprocset();
  741. Xvoid insertproc();
  742. Xchar *newstring();
  743. Xvoid newprocset();
  744. Xvoid readprocfile();
  745. Xvoid Usage();
  746. X
  747. Xmain(argc, argv)
  748. Xint argc;
  749. Xchar **argv;
  750. X{
  751. X    register STR *str;
  752. X    register char *cp;
  753. X    long ltime;
  754. X    char *ctime();
  755. X
  756. X#ifndef CONFIGDIR
  757. X    ucbwhich(*argv);
  758. X#endif CONFIGDIR
  759. X    strcat(ucblib, "/");
  760. X    if(myname = rindex(*argv, '/'))
  761. X        myname++;
  762. X    else
  763. X        myname = *argv;
  764. X    cp = NULL;
  765. X    for(argc--, argv++ ; argc > 0 && **argv == '-' ; argc--, argv++) {
  766. X        switch((*argv)[1]) {
  767. X         case 'c':    /* multiple copies */
  768. X            if((*argv)[2])
  769. X                ncopies = atoi(&(*argv[2]));
  770. X            else {
  771. X                if(argc < 2)
  772. X                    Usage();    /* never returns */
  773. X                argc--;
  774. X                ncopies = atoi(*++argv);
  775. X            }
  776. X            if(ncopies <= 0)
  777. X                Usage();    /* never returns */
  778. X            break;
  779. X         case 'd':    /* alternate directory for config file */
  780. X            if((*argv)[2])
  781. X                cp = &(*argv[2]);
  782. X            else {
  783. X                if(argc < 2)
  784. X                    Usage();    /* never returns */
  785. X                argc--;
  786. X                cp = *++argv;
  787. X            }
  788. X            strcpy(ucblib, cp);
  789. X            break;
  790. X         case 'r':    /* raw mode */
  791. X            rawmode++;
  792. X            break;
  793. X         default:
  794. X            Usage();    /* never returns */
  795. X        }
  796. X    }
  797. X    if(argc > 1)
  798. X        Usage();    /* never returns */
  799. X    if(argc == 1 && freopen(*argv, "r", stdin) == NULL) {
  800. X        fprintf(stderr, "%s: can't open %s\n", myname, *argv);
  801. X        exit(1);
  802. X    }
  803. X    readprocfile();
  804. X    str = STRalloc();
  805. X    if(!STRgets(str, stdin)) {
  806. X        fprintf(stderr, "%s: Null input\n", myname);
  807. X        exit(1);
  808. X    }
  809. X    time(<ime);
  810. X    printf(intro, ctime(<ime));
  811. X    do {
  812. X        if(ncopies != 0 && STRheadcompare(str, "userdict /#copies ")
  813. X         == 0)
  814. X            continue;
  815. X        if(STRcompare(str, "%%EOF\n") == 0) {
  816. X#ifdef SAVE
  817. X            if(finale) {
  818. X                fputs(finale, stdout);
  819. X                finale = NULL;
  820. X            }
  821. X#endif SAVE
  822. X            STRputs(str, stdout);
  823. X            continue;
  824. X        }
  825. X        if(STRheadcompare(str, "%%IncludeProcSet:") == 0) {
  826. X            insertproc(str, INCLUDEPROC);
  827. X            continue;
  828. X        }
  829. X        if(STRheadcompare(str, "%%BeginProcSet:") == 0) {
  830. X            insertproc(str, BEGINPROC);
  831. X            continue;
  832. X        }
  833. X        STRputs(str, stdout);
  834. X        if(ncopies > 1 && isascii(*str->bufptr) &&
  835. X         isdigit(*str->bufptr)) {
  836. X            cp = (char *)str->bufptr;
  837. X            while(cp < (char *)str->curendptr && isascii(*cp)
  838. X             && isdigit(*cp))
  839. X                cp++;
  840. X            if((char *)str->curendptr - cp == 4 &&
  841. X             STRcompareptr(str, cp, " mf\n") == 0) {
  842. X                printf("userdict /#copies %d put\n", ncopies);
  843. X                ncopies = -1;
  844. X            }
  845. X        }
  846. X    } while(STRgets(str, stdin));
  847. X#ifdef SAVE
  848. X    if(finale)
  849. X        fputs(finale, stdout);
  850. X#endif SAVE
  851. X    exit(0);
  852. X}
  853. X
  854. Xvoid
  855. Xinsertproc(str, beginproc)
  856. Xregister STR *str;
  857. Xint beginproc;
  858. X{
  859. X    register char *cp, *pp;
  860. X    register int i, n, fd;
  861. X    register ProcSet *ps;
  862. X    char buf[BUFSIZ];
  863. X
  864. X    cp = index((char *)str->bufptr, ':') + 1;
  865. X    strcpy(buf, cp);
  866. X    cp = buf;
  867. X    for( ; ; cp++) {
  868. X        if(!*cp) {
  869. X            fprintf(stderr,
  870. X         "%s: Syntax error on IncludeProcSet/BeginProcSet line\n",
  871. X             myname);
  872. X            exit(1);
  873. X        }
  874. X        if(!isascii(*cp) || !isspace(*cp))
  875. X            break;
  876. X    }
  877. X    pp = cp + strlen(cp);
  878. X    while(--pp >= cp) {
  879. X        if(!isascii(*pp) || !isspace(*pp))
  880. X            break;
  881. X        *pp = 0;
  882. X    }
  883. X    if((ps = findprocset(cp)) == NULL) {
  884. X        if(beginproc) {
  885. X            STRputs(str, stdout);
  886. X            copyproc(str, stdout);
  887. X            return;
  888. X        }
  889. X        fprintf(stderr, "%s: Unknown IncludeProcSet %s\n",
  890. X         myname, cp);
  891. X        exit(1);
  892. X    }
  893. X    if(ps->flags & PS_INCLUDED)
  894. X        return;
  895. X    ps->flags |= PS_INCLUDED;
  896. X    if(*(ps->path) == '/')
  897. X        strcpy(buf, ps->path);
  898. X    else {
  899. X        strcpy(buf, ucblib);
  900. X        strcat(buf, ps->path);
  901. X    }
  902. X    fflush(stdout);
  903. X    if((fd = open(buf, O_RDONLY, 0)) < 0) {
  904. X        fprintf(stderr, "%s: Can't open %s\n", myname, buf);
  905. X        exit(1);
  906. X    }
  907. X    if(beginproc)
  908. X        copyproc(str, NULL);
  909. X    while((i = read(fd, buf, BUFSIZ)) > 0) {
  910. X        do {
  911. X            if((n = write(1, buf, i)) < 0) {
  912. X                fprintf(stderr, "%s: Write error\n", myname);
  913. X                exit(1);
  914. X            }
  915. X        } while((i -= n) > 0);
  916. X    }
  917. X    close(fd);
  918. X}
  919. X
  920. Xvoid
  921. Xreadprocfile()
  922. X{
  923. X    register FILE *fp;
  924. X    register char *pp;
  925. X    register int linenum;
  926. X    char buf[BUFSIZ];
  927. X
  928. X    strcpy(buf, ucblib);
  929. X    strcat(buf, CONFIG);
  930. X    if((fp = fopen(buf, "r")) == NULL) {
  931. X        fprintf(stderr, "%s: Can't open %s\n", myname, buf);
  932. X        exit(1);
  933. X    }
  934. X    linenum = 0;
  935. X    while(fgets(buf, BUFSIZ, fp)) {
  936. X        linenum++;
  937. X        if(*buf == '#')
  938. X            continue;
  939. X        if(pp = index(buf, '\n')) {
  940. X            if(pp == buf)
  941. X                continue;
  942. X            *pp = 0;
  943. X        }
  944. X        if(!(pp = index(buf, '\t'))) {
  945. X            fprintf(stderr,
  946. X             "%s: Syntax error in macps.config, line %d\n",
  947. X             myname, linenum);
  948. X            exit(1);
  949. X        }
  950. X        *pp++ = 0;
  951. X        newprocset(buf, pp);
  952. X    }
  953. X    fclose(fp);
  954. X}
  955. X
  956. Xvoid
  957. Xcopyproc(str, fp)
  958. Xregister STR *str;
  959. Xregister FILE *fp;
  960. X{
  961. X    for( ; ; ) {
  962. X        if(!STRgets(str, stdin)) {
  963. X            fprintf(stderr, "%s: End of file copying ProcSet\n",
  964. X             myname);
  965. X            exit(1);
  966. X        }
  967. X        if(fp)
  968. X            STRputs(str, fp);
  969. X        if(STRheadcompare(str, "%%EndProcSet") == 0)
  970. X            return;
  971. X    }
  972. X}
  973. X
  974. Xvoid
  975. Xnewprocset(procset, path)
  976. Xchar *procset, *path;
  977. X{
  978. X    register ProcSet *ps;
  979. X    char *calloc();
  980. X
  981. X    if((ps = (ProcSet *)calloc(1, sizeof(ProcSet))) == NULL) {
  982. X        fprintf(stderr, "%s: Out of memory allocating ProcSet\n",
  983. X         myname);
  984. X        exit(1);
  985. X    }
  986. X    if(firstprocset) {
  987. X        lastprocset->next = ps;
  988. X        lastprocset = ps;
  989. X    } else
  990. X        firstprocset = lastprocset = ps;
  991. X    ps->procset = newstring(procset);
  992. X    ps->path = newstring(path);
  993. X}
  994. X
  995. XProcSet *
  996. Xfindprocset(procset)
  997. Xregister char *procset;
  998. X{
  999. X    register ProcSet *ps;
  1000. X
  1001. X    for(ps = firstprocset ; ps ; ps = ps->next) {
  1002. X        if(strcmp(procset, ps->procset) == 0)
  1003. X            return(ps);
  1004. X    }
  1005. X    return(NULL);
  1006. X}
  1007. X
  1008. Xchar *
  1009. Xnewstring(str)
  1010. Xregister char *str;
  1011. X{
  1012. X    register char *cp;
  1013. X    char *malloc();
  1014. X
  1015. X    if((cp = malloc(strlen(str) + 1)) == NULL) {
  1016. X        fprintf(stderr, "%s: Out of memory allocating string\n",
  1017. X         myname);
  1018. X        exit(1);
  1019. X    }
  1020. X    strcpy(cp, str);
  1021. X    return(cp);
  1022. X}
  1023. X
  1024. Xvoid
  1025. XUsage()
  1026. X{
  1027. X    fputs("Usage: macps [-c #] [-d directory] [-r] [file]\n", stderr);
  1028. X    exit(1);
  1029. X}
  1030. END_OF_FILE
  1031. if test 7130 -ne `wc -c <'macps.c'`; then
  1032.     echo shar: \"'macps.c'\" unpacked with wrong size!
  1033. fi
  1034. # end of 'macps.c'
  1035. fi
  1036. if test -f 'macps.config' -a "${1}" != "-c" ; then 
  1037.   echo shar: Will not clobber existing file \"'macps.config'\"
  1038. else
  1039. echo shar: Extracting \"'macps.config'\" \(578 characters\)
  1040. sed "s/^X//" >'macps.config' <<'END_OF_FILE'
  1041. X# This is the config file read by macps.
  1042. X# SCCSid = "@(#)macps.config    2.3 7/1/92"
  1043. X#
  1044. X# Each line is composed of the %%IncludeProcSet id, a tab and the file
  1045. X# containing the ProcSet.  If the file doesn't begin with a slash, the
  1046. X# the name is taken to be relative to the directory in which this config file
  1047. X# resides.
  1048. X
  1049. X"(AppleDict md)" 65 0    ProcSets/LaserPrep4.0
  1050. X"(AppleDict md)" 66    ProcSets/LaserPrep5.0
  1051. X"(AppleDict md)" 67 0    ProcSets/LaserPrep5.1
  1052. X"(AppleDict md)" 68 0    ProcSets/LaserPrep5.2
  1053. X"(AppleDict md)" 70 0    ProcSets/LaserPrep6.0
  1054. X"(AppleDict md)" 71 0    ProcSets/LaserPrep7.0
  1055. END_OF_FILE
  1056. if test 578 -ne `wc -c <'macps.config'`; then
  1057.     echo shar: \"'macps.config'\" unpacked with wrong size!
  1058. fi
  1059. # end of 'macps.config'
  1060. fi
  1061. if test -f 'prepfix.1' -a "${1}" != "-c" ; then 
  1062.   echo shar: Will not clobber existing file \"'prepfix.1'\"
  1063. else
  1064. echo shar: Extracting \"'prepfix.1'\" \(2344 characters\)
  1065. sed "s/^X//" >'prepfix.1' <<'END_OF_FILE'
  1066. X.\" SCCSid = "@(#)prepfix.1    2.3 7/1/92"
  1067. X.TH PREPFIX 1 "1 Jul 1992"
  1068. X.UC 4
  1069. X.SH NAME
  1070. Xprepfix \- converts Apple LaserPrep files to form useable on Unix
  1071. X.SH SYNOPSIS
  1072. X.B prepfix
  1073. X[
  1074. X\-l
  1075. Xprinter_name1
  1076. X[
  1077. X\-l
  1078. Xprinter_name2
  1079. X]...
  1080. X]
  1081. X[
  1082. Xfile
  1083. X]
  1084. X.SH DESCRIPTION
  1085. X.I Prepfix
  1086. Xtakes the command-line LaserPrep file (or the standard input if no filename is
  1087. Xgiven), and converts it into a form that is useable on Unix with the
  1088. X.IR macps (1).
  1089. X.PP
  1090. XTo use
  1091. X.IR prepfix ,
  1092. Xcreate the input LaserPrep file on a Macintosh by opening an empty
  1093. Xdocument in some application, and selecting
  1094. X.B Print
  1095. Xfrom the
  1096. X.B File
  1097. Xmenu.
  1098. XOn a pre-System 7 system, typing (and holding) Command-K immediately after
  1099. Xclicking the
  1100. X.B OK
  1101. Xbutton in the LaserWriter print dialog box will cause
  1102. Xanother dialog to appear, confirming that a file named ``PostScript'' is
  1103. Xbeing created (the Command-K keys can be released now).
  1104. XDepending on the application, the created PostScript file can be found in the
  1105. XSystem Folder, the application folder or the top level of the disk.
  1106. X.PP
  1107. XOn a System 7 system, clicking on the
  1108. X.B "PostScript File"
  1109. Xradio button and then clicking on the
  1110. X.B Save
  1111. Xbutton will cause a standard file dialog to appear, requesting the name
  1112. Xand location to save the PostScript file.
  1113. X.PP
  1114. XThis PostScript file can then be uploaded via some file transfer program,
  1115. Xsuch as MacTerminal/VersaTerm and
  1116. X.IR macget (1),
  1117. XMacKermit/Red Ryder and
  1118. X.IR kermit (1)
  1119. Xor
  1120. X.IR ftp (1).
  1121. X.PP
  1122. XNormally, only Apple LaserWriters can take advantage of the bit smoothing
  1123. Xfeature of the LaserPrep file.
  1124. XHowever, other PostScript laser printer using the Motorola 680x0 processor
  1125. Xand the Adobe PostScript firmware can be made to do bit smoothing by
  1126. Xspecifying for each printer the
  1127. X.B \-l
  1128. Xoption and the printer's name, as returned by the PostScript
  1129. X.B product
  1130. Xcommand in
  1131. X.B statusdict
  1132. X(remember to quote the printer name if it contains blanks).
  1133. XThe resulting LaserPrep file will be modified so that for LaserWriters and for
  1134. Xprinters specified in the
  1135. X.B \-l
  1136. Xoption, bit smoothing will be allowed (smoothing must still be selected in the
  1137. XPrint Dialog box when saving the PostScript to disk).
  1138. XMore than one printer name can be specified using additional
  1139. X.B \-l
  1140. Xand printer name pairs.
  1141. X.SH "SEE ALSO"
  1142. Xftp(1), macps(1), macget(1), kermit(1)
  1143. X.SH BUGS
  1144. X.I Prepfix
  1145. Xonly works with version 4.0 and up of the Macintosh LaserPrep files.
  1146. END_OF_FILE
  1147. if test 2344 -ne `wc -c <'prepfix.1'`; then
  1148.     echo shar: \"'prepfix.1'\" unpacked with wrong size!
  1149. fi
  1150. # end of 'prepfix.1'
  1151. fi
  1152. if test -f 'prepfix.c' -a "${1}" != "-c" ; then 
  1153.   echo shar: Will not clobber existing file \"'prepfix.c'\"
  1154. else
  1155. echo shar: Extracting \"'prepfix.c'\" \(6274 characters\)
  1156. sed "s/^X//" >'prepfix.c' <<'END_OF_FILE'
  1157. X/*
  1158. X * Copyright (c) 1988, 1992, The Regents of the University of California.
  1159. X * Edward Moy, Workstation Software Support Group, Workstation Support Serices,
  1160. X * Information Systems and Technology.
  1161. X *
  1162. X * Permission is granted to any individual or institution to use, copy,
  1163. X * or redistribute this software so long as it is not sold for profit,
  1164. X * provided that this notice and the original copyright notices are
  1165. X * retained.  The University of California makes no representations about the
  1166. X * suitability of this software for any purpose.  It is provided "as is"
  1167. X * without express or implied warranty.
  1168. X */
  1169. X
  1170. X#ifndef lint
  1171. Xstatic char *SCCSid = "@(#)prepfix.c    2.3 7/1/92";
  1172. X#endif lint
  1173. X
  1174. X#include <ctype.h>
  1175. X#include <stdio.h>
  1176. X#ifdef SYSV
  1177. X#include <string.h>
  1178. X#else SYSV
  1179. X#include <strings.h>
  1180. X#endif SYSV
  1181. X#include "str.h"
  1182. X
  1183. X#define    CLEARTOMARK    12
  1184. X#define EEXECLEN    80
  1185. X#define EXTRA        (NZEROLINE * ZEROLINE + CLEARTOMARK)
  1186. X#define LINELEN        256
  1187. X#define    NPRODUCTS    32
  1188. X#define NZEROLINE    7
  1189. X#define ZEROLINE    65
  1190. X#ifdef SYSV
  1191. X#define    index        strchr
  1192. X#define    rindex        strrchr
  1193. X#endif SYSV
  1194. X
  1195. Xchar exstr[] = "\
  1196. X%ck userdict/%s known not and{currentfile eexec}{%d{currentfile read\n\
  1197. Xpop pop}repeat}ifelse\n\
  1198. X";
  1199. Xchar *match();
  1200. Xchar *myname;
  1201. Xint maxproducts = NPRODUCTS;
  1202. Xint nproducts = 0;
  1203. Xchar Ok[] = "\
  1204. X/Ok{ok{true}{save /Pd statusdict /product get def false 0 1 ProdArr length\n\
  1205. X1 sub{Pd exch ProdArr exch get anchorsearch exch pop{pop pop true exit}if}for\n\
  1206. Xexch restore}ifelse}bind def\n\
  1207. X";
  1208. Xchar ProdArr0[] = "/ProdArr [\n";
  1209. Xchar ProdArr1[] = "] def\n";
  1210. Xchar **products;
  1211. Xchar tempname[] = "/tmp/prepfixXXXXXX";
  1212. X
  1213. Xmain(argc, argv)
  1214. Xint argc;
  1215. Xchar **argv;
  1216. X{
  1217. X    register STR *str;
  1218. X    register FILE *tp;
  1219. X    register int i;
  1220. X    register byte *lp;
  1221. X    char buf[BUFSIZ];
  1222. X    char *malloc(), *realloc();
  1223. X
  1224. X    if(myname = rindex(*argv, '/'))
  1225. X        myname++;
  1226. X    else
  1227. X        myname = *argv;
  1228. X    for(argc--, argv++ ; argc > 0 && **argv == '-' ; argc--, argv++) {
  1229. X        switch((*argv)[1]) {
  1230. X         case 'h':
  1231. X            usage();
  1232. X         case 'l':
  1233. X            if(nproducts <= 0 && (products =
  1234. X             (char **)malloc(maxproducts*sizeof(char *))) == NULL) {
  1235. X                fprintf(stderr,
  1236. X                 "%s: Out of memory creating products array\n",
  1237. X                 myname);
  1238. X                exit(1);
  1239. X            } else if(nproducts >= maxproducts - 1 && (products =
  1240. X             (char **)realloc(products, (maxproducts += NPRODUCTS)
  1241. X             * sizeof(char *))) == NULL) {
  1242. X                fprintf(stderr,
  1243. X                 "%s: Out of memory expanding products array\n",
  1244. X                 myname);
  1245. X                exit(1);
  1246. X            }
  1247. X            if((*argv)[2])
  1248. X                products[nproducts++] = &(*argv)[2];
  1249. X            else {
  1250. X                if(argc < 2) {
  1251. X                    fprintf(stderr,
  1252. X                     "%s: No argument for -l\n", myname);
  1253. X                    exit(1);
  1254. X                }
  1255. X                argc--;
  1256. X                argv++;
  1257. X                products[nproducts++] = *argv;
  1258. X            }
  1259. X            break;
  1260. X        }
  1261. X    }
  1262. X    if(argc > 1)
  1263. X        usage();
  1264. X    if(argc > 0 && freopen(*argv, "r", stdin) == NULL) {
  1265. X        fprintf(stderr, "%s: Can't open %s\n", myname, *argv);
  1266. X        exit(1);
  1267. X    }
  1268. X    mktemp(tempname);
  1269. X    if((tp = fopen(tempname, "w+")) == NULL) {
  1270. X        fprintf(stderr, "%s: Can't create temp file %s\n",
  1271. X         myname, tempname);
  1272. X        exit(1);
  1273. X    }
  1274. X    unlink(tempname);
  1275. X    str = STRalloc();
  1276. X    if(!STRgets(str, stdin)) {
  1277. X        fprintf(stderr, "%s: Null input\n", myname);
  1278. X        exit(1);
  1279. X    }
  1280. X    for( ; ; ) {
  1281. X        if(STRheadcompare(str, "% \251") == 0) {
  1282. X            fputs("% ", tp);
  1283. X            str->bufptr[0] = '(';
  1284. X            str->bufptr[1] = 'C';
  1285. X            str->bufptr[2] = ')';
  1286. X            STRputs(str, tp);
  1287. X        } else if(STRheadcompare(str, "%% \251") == 0) {
  1288. X            fputs("%%", tp);
  1289. X            str->bufptr[0] = ' ';
  1290. X            str->bufptr[1] = '(';
  1291. X            str->bufptr[2] = 'C';
  1292. X            str->bufptr[3] = ')';
  1293. X            STRputs(str, tp);
  1294. X        } else if(STRheadcompare(str, "%%BeginProcSet:") == 0) {
  1295. X            STRputs(str, stdout);
  1296. X            rewind(tp);
  1297. X            while((i = fread(buf, 1, BUFSIZ, tp)) > 0)
  1298. X                fwrite(buf, 1, i, stdout);
  1299. X            fclose(tp);
  1300. X            break;
  1301. X        } else if(STRheadcompare(str, "%{appledict") == 0)
  1302. X            STRputs(str, tp);
  1303. X        if(!STRgets(str, stdin)) {
  1304. X            fprintf(stderr, "%s: No BeginProcSet\n", myname);
  1305. X            exit(1);
  1306. X        }
  1307. X    }
  1308. X    while(STRgets(str, stdin)) {
  1309. X        if(nproducts > 0 && STRmatch(str, "/ok{")) {
  1310. X            STRputs(str, stdout);
  1311. X            fputs(ProdArr0, stdout);
  1312. X            for(i = 0 ; i < nproducts ; i++)
  1313. X                printf("(%s)\n", products[i]);
  1314. X            fputs(ProdArr1, stdout);
  1315. X            fputs(Ok, stdout);
  1316. X            continue;
  1317. X        } else if(STRmatch(str, "setdefaulttimeouts")
  1318. X         || STRmatch(str, "setsccinteractive"))
  1319. X            continue;
  1320. X        else if(STRmatch(str, " checkload")) {
  1321. X            checkload(str);
  1322. X            continue;
  1323. X        } else if(STRmatch(str, "/stretch") && STRmatch(str, "eexec")) {
  1324. X            eexec("stretch", str);
  1325. X            continue;
  1326. X        } else if(STRmatch(str, "/smooth4") && STRmatch(str, "eexec")) {
  1327. X            eexec("smooth4", str);
  1328. X            continue;
  1329. X        } else if(STRmatch(str, "(LaserWriter II NT)")) {
  1330. X            while(STRgets(str, stdin) && STRheadcompare(str, "35de")
  1331. X             != 0)
  1332. X                { /* ignore line */ }
  1333. X            while(STRgets(str, stdin) && isxdigit(*str->bufptr))
  1334. X                { /* ignore line */ }
  1335. X        } else if(lp = STRmatch(str, "scaleby96{ppr")) {
  1336. X            STRputsptr(str, lp, stdout);
  1337. X            continue;
  1338. X        } else if(STRmatch(str, "waittimeout"))
  1339. X            continue;
  1340. X        else if(STRheadcompare(str, "%%EndProcSet") == 0) {
  1341. X            STRputs(str, stdout);
  1342. X            break;
  1343. X        }
  1344. X        STRputs(str, stdout);
  1345. X    }
  1346. X    exit(0);
  1347. X}
  1348. X
  1349. Xeexec(name, str)
  1350. Xchar *name;
  1351. Xregister STR *str;
  1352. X{
  1353. X    register int len;
  1354. X
  1355. X    if(!STRgets(str, stdin)) {
  1356. X        fprintf(stderr, "%s: EOF during reading eexec\n", myname);
  1357. X        exit(1);
  1358. X    }
  1359. X    len = (str->curendptr - str->bufptr) - 1;
  1360. X    printf(exstr, nproducts > 0 ? 'O' : 'o', name, len + (len / EEXECLEN)
  1361. X     + (len % EEXECLEN ? 1 : 0) + EXTRA);
  1362. X    spliteexec(str);
  1363. X}
  1364. X
  1365. Xcheckload(str)
  1366. Xregister STR *str;
  1367. X{
  1368. X    register byte *cp;
  1369. X
  1370. X    if(nproducts > 0 && (cp = STRmatch(str, "ok ")))
  1371. X        *cp = 'O';
  1372. X    STRputs(str, stdout);
  1373. X    if(!STRgets(str, stdin)) {
  1374. X        fprintf(stderr, "%s: EOF during reading eexec\n", myname);
  1375. X        exit(1);
  1376. X    }
  1377. X    spliteexec(str);
  1378. X}
  1379. X
  1380. Xspliteexec(str)
  1381. Xregister STR *str;
  1382. X{
  1383. X    register int len;
  1384. X    register byte *bp;
  1385. X
  1386. X    bp = str->bufptr;
  1387. X    len = (str->curendptr - bp) - 1;
  1388. X    while(len >= 80) {
  1389. X        fwrite(bp, 80, 1, stdout);
  1390. X        putchar('\n');
  1391. X        bp += 80;
  1392. X        len -= 80;
  1393. X    }
  1394. X    if(len > 0) {
  1395. X        fwrite(bp, len, 1, stdout);
  1396. X        putchar('\n');
  1397. X    }
  1398. X    for( ; ; ) {
  1399. X        if(!STRgets(str, stdin)) {
  1400. X            fprintf(stderr, "%s: EOF reached before cleartomark\n",
  1401. X             myname);
  1402. X            exit(1);
  1403. X        }
  1404. X        STRputs(str, stdout);
  1405. X        if(STRheadcompare(str, "cleartomark") == 0)
  1406. X            return;
  1407. X    }
  1408. X}
  1409. X
  1410. Xusage()
  1411. X{
  1412. X    fprintf(stderr,
  1413. X     "Usage: %s [-l product_name1 [-l product_name2]...] [file]\n",
  1414. X     myname);
  1415. X    fprintf(stderr, "       %s -help\n", myname);
  1416. X    exit(1);
  1417. X}
  1418. END_OF_FILE
  1419. if test 6274 -ne `wc -c <'prepfix.c'`; then
  1420.     echo shar: \"'prepfix.c'\" unpacked with wrong size!
  1421. fi
  1422. # end of 'prepfix.c'
  1423. fi
  1424. if test -f 'str.h' -a "${1}" != "-c" ; then 
  1425.   echo shar: Will not clobber existing file \"'str.h'\"
  1426. else
  1427. echo shar: Extracting \"'str.h'\" \(1156 characters\)
  1428. sed "s/^X//" >'str.h' <<'END_OF_FILE'
  1429. X/*
  1430. X * Copyright (c) 1988, 1992, The Regents of the University of California.
  1431. X * Edward Moy, Workstation Software Support Group, Workstation Support Serices,
  1432. X * Information Systems and Technology.
  1433. X *
  1434. X * Permission is granted to any individual or institution to use, copy,
  1435. X * or redistribute this software so long as it is not sold for profit,
  1436. X * provided that this notice and the original copyright notices are
  1437. X * retained.  The University of California makes no representations about the
  1438. X * suitability of this software for any purpose.  It is provided "as is"
  1439. X * without express or implied warranty.
  1440. X */
  1441. X
  1442. X/*
  1443. X * SCCSid = "@(#)str.h    2.3 7/1/92"
  1444. X */
  1445. X
  1446. X#define    STRSIZEDELTA    1024
  1447. X#define    STRSIZE        1024
  1448. X
  1449. X#define    STRcompare(str,fp)    STRcompareptr((str), (str)->bufptr, (fp))
  1450. X#define    STRheadcompare(str,fp)    STRheadcmpptr((str), (str)->bufptr, (fp))
  1451. X#define    STRputs(str,fp)        STRputsptr((str), (str)->bufptr, (fp))
  1452. X
  1453. Xtypedef unsigned char byte;
  1454. Xtypedef struct {
  1455. X    byte *bufptr;
  1456. X    byte *curendptr;
  1457. X    byte *realendptr;
  1458. X} STR;
  1459. X
  1460. Xextern int rawmode;
  1461. X
  1462. XSTR *STRalloc();
  1463. Xint STRcompareptr();
  1464. Xint STRfree();
  1465. Xint STRgets();
  1466. Xint STRheadcmpptr();
  1467. Xbyte *STRmatch();
  1468. Xint STRputsptr();
  1469. END_OF_FILE
  1470. if test 1156 -ne `wc -c <'str.h'`; then
  1471.     echo shar: \"'str.h'\" unpacked with wrong size!
  1472. fi
  1473. # end of 'str.h'
  1474. fi
  1475. if test -f 'ucbwhich.c' -a "${1}" != "-c" ; then 
  1476.   echo shar: Will not clobber existing file \"'ucbwhich.c'\"
  1477. else
  1478. echo shar: Extracting \"'ucbwhich.c'\" \(3277 characters\)
  1479. sed "s/^X//" >'ucbwhich.c' <<'END_OF_FILE'
  1480. X/*
  1481. X * Copyright (c) 1988, 1992, The Regents of the University of California.
  1482. X * Edward Moy, Workstation Software Support Group, Workstation Support Serices,
  1483. X * Information Systems and Technology.
  1484. X *
  1485. X * Permission is granted to any individual or institution to use, copy,
  1486. X * or redistribute this software so long as it is not sold for profit,
  1487. X * provided that this notice and the original copyright notices are
  1488. X * retained.  The University of California makes no representations about the
  1489. X * suitability of this software for any purpose.  It is provided "as is"
  1490. X * without express or implied warranty.
  1491. X */
  1492. X
  1493. X#ifndef CONFIGDIR
  1494. X#ifndef lint
  1495. Xstatic char *SCCSid = "@(#)ucbwhich.c    2.3 7/1/92";
  1496. X#endif lint
  1497. X
  1498. X#include <stdio.h>
  1499. X#include <sys/types.h>
  1500. X#include <sys/stat.h>
  1501. X#include "ucbwhich.h"
  1502. X
  1503. X#define    F_OK        0    /* does file exist */
  1504. X#define    X_OK        1    /* is it executable by caller */
  1505. X#define    W_OK        2    /* writable by caller */
  1506. X#define    R_OK        4    /* readable by caller */
  1507. X
  1508. X#define    LIBLEN        4
  1509. X#ifdef SYSV
  1510. X#define    index        strchr
  1511. X#define    rindex        strrchr
  1512. X#endif SYSV
  1513. X
  1514. Xstatic char lib[] = "/lib";
  1515. X
  1516. Xchar ucblib[UCBMAXPATHLEN];
  1517. Xint ucbalternate = 0;
  1518. Xchar ucbpath[UCBMAXPATHLEN];
  1519. X
  1520. Xucbwhich(str)
  1521. Xchar *str;
  1522. X{
  1523. X    register char *dir, *name, *cp, *tp;
  1524. X    register int len;
  1525. X    char dirbuf[UCBMAXPATHLEN], namebuf[UCBMAXPATHLEN];
  1526. X    struct stat sbuf;
  1527. X    char *index(), *rindex(), *getwd(), *getenv();
  1528. X
  1529. X    strcpy(name = namebuf, str);
  1530. X    if(*name == '/')    /* absolute pathname */
  1531. X        *(rindex(dir = name, '/')) = 0 ; /* remove tail */
  1532. X    else {
  1533. X        if(cp = index(name, '/')) { /* relative pathname */
  1534. X            if((dir = getwd(dirbuf)) == NULL)
  1535. X                return(0);
  1536. X             /* if any errors occurs assume standard version */
  1537. X            *cp++ = 0;
  1538. X            for( ; ; ) {
  1539. X                if(*name != 0) { /* multiple slashes */
  1540. X                    if(strcmp(name, "..") == 0) {
  1541. X                        /* parent directory */
  1542. X                        if((tp = rindex(dir, '/')) ==
  1543. X                         NULL)
  1544. X                             return(0);
  1545. X                        if(tp == dir)
  1546. X                            tp++;
  1547. X                         /* root directory */
  1548. X                        *tp = 0;
  1549. X                         /* remove last component */
  1550. X                    } else if(strcmp(name, ".") != 0) {
  1551. X                        /* subdirectory */
  1552. X                        strcat(dir, "/");
  1553. X                        strcat(dir, name);
  1554. X                    }
  1555. X                }
  1556. X                name = cp;
  1557. X                if((cp = index(name, '/')) == NULL) break;
  1558. X                /* ignore last component */
  1559. X                *cp++ = 0;
  1560. X            }
  1561. X        } else { /* look through $PATH variable */
  1562. X            if((tp = getenv("PATH")) == NULL)
  1563. X                return(0);
  1564. X            for(name = namebuf ; ; ) {
  1565. X                if(*tp == 0)
  1566. X                    return(0);
  1567. X                else if(*tp == ':')
  1568. X                    tp++;
  1569. X                if((cp = index(tp, ':')) == NULL)
  1570. X                    cp = tp + strlen(tp);
  1571. X                 /* positioned on null */
  1572. X                for(dir = dirbuf ; tp < cp ; )
  1573. X                    *dir++ = *tp++;
  1574. X                *dir = 0;
  1575. X                strcpy(name, dir = dirbuf);
  1576. X                strcat(name, "/");
  1577. X                strcat(name, str);
  1578. X                if(stat(name, &sbuf) < 0 || (sbuf.st_mode &
  1579. X                 S_IFMT) != S_IFREG)
  1580. X                    continue;
  1581. X                if(access(name, X_OK) == 0) {
  1582. X                    if(strcmp(dir, ".") == 0 &&
  1583. X                     (dir = getwd(dirbuf)) == NULL)
  1584. X                        return(0);
  1585. X                    break;
  1586. X                }
  1587. X            }
  1588. X        }
  1589. X    }
  1590. X    strcpy(ucbpath, dir);
  1591. X    strcpy(ucblib, dir);
  1592. X    if((len = strlen(dir)) < LIBLEN || strcmp(&dir[len - LIBLEN], lib)
  1593. X     != 0)
  1594. X        strcat(ucblib, lib);
  1595. X    else
  1596. X        ucbpath[len - LIBLEN] = 0;
  1597. X    ucbalternate = (strcmp(ucbpath, UCBSTANDARD) != 0);
  1598. X#ifdef EBUG
  1599. X    fprintf(stderr, "ucbwhich: alt=%d path=%s lib=%s\n", ucbalternate,
  1600. X     ucbpath, ucblib);
  1601. X#endif EBUG
  1602. X    return(ucbalternate);
  1603. X}
  1604. X#endif CONFIGDIR
  1605. END_OF_FILE
  1606. if test 3277 -ne `wc -c <'ucbwhich.c'`; then
  1607.     echo shar: \"'ucbwhich.c'\" unpacked with wrong size!
  1608. fi
  1609. # end of 'ucbwhich.c'
  1610. fi
  1611. if test -f 'ucbwhich.h' -a "${1}" != "-c" ; then 
  1612.   echo shar: Will not clobber existing file \"'ucbwhich.h'\"
  1613. else
  1614. echo shar: Extracting \"'ucbwhich.h'\" \(782 characters\)
  1615. sed "s/^X//" >'ucbwhich.h' <<'END_OF_FILE'
  1616. X/*
  1617. X * Copyright (c) 1988, 1992, The Regents of the University of California.
  1618. X * Edward Moy, Workstation Software Support Group, Workstation Support Serices,
  1619. X * Information Systems and Technology.
  1620. X *
  1621. X * Permission is granted to any individual or institution to use, copy,
  1622. X * or redistribute this software so long as it is not sold for profit,
  1623. X * provided that this notice and the original copyright notices are
  1624. X * retained.  The University of California makes no representations about the
  1625. X * suitability of this software for any purpose.  It is provided "as is"
  1626. X * without express or implied warranty.
  1627. X */
  1628. X
  1629. X/*
  1630. X * SCCSid = "@(#)ucbwhich.h    2.3 7/1/92"
  1631. X */
  1632. X
  1633. X#define    UCBMAXPATHLEN    128
  1634. X#define    UCBSTANDARD    "/usr/ucb"
  1635. X
  1636. Xextern char ucblib[];
  1637. Xextern int ucbalternate;
  1638. Xextern char ucbpath[];
  1639. END_OF_FILE
  1640. if test 782 -ne `wc -c <'ucbwhich.h'`; then
  1641.     echo shar: \"'ucbwhich.h'\" unpacked with wrong size!
  1642. fi
  1643. # end of 'ucbwhich.h'
  1644. fi
  1645. echo shar: End of archive 1 \(of 1\).
  1646. cp /dev/null ark1isdone
  1647. MISSING=""
  1648. for I in 1 ; do
  1649.     if test ! -f ark${I}isdone ; then
  1650.     MISSING="${MISSING} ${I}"
  1651.     fi
  1652. done
  1653. if test "${MISSING}" = "" ; then
  1654.     echo You have the archive.
  1655.     rm -f ark[1-9]isdone
  1656. else
  1657.     echo You still need to unpack the following archives:
  1658.     echo "        " ${MISSING}
  1659. fi
  1660. ##  End of shell archive.
  1661. exit 0
  1662.